﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace XNAFight.Characters.Core
{
    public class Hit
    {
        #region CHAMPS

        /*Ces variables là, on verra plus tard :)
        
        // Variables qui concernent l'impact sur l'adversaire 
        private int nbFHitStun;
        private int nbFBlockStun;
        private int degats;
        private int stun;
         
        // Liste des variables concernant la "cancellabilité" du coup
        private bool superCancellable;
        private bool jumpCancellable;
        private bool specialCancellable;
        private bool normalCancellable;
        */
        
        // Liste des variables décrivant le comportement du coup dans le temps
        private int nbFStart;
        private int nbFActives;
        private int nbFRecup;

        // frames du hit et de ses attributs, pour setter correctement le flag de position verticale du perso pendant le hit
        int airborn_start, airborn_end;
        int stand_start, stand_end;
        int crouch_start, crouch_end;

        // frames d'anime correspondant aux étapes du hit
        int startingFStart, endingFStart;
        int startingFActive, endingFActive;
        int startingFRecup, endingFRecup;

        // les états du hit
        enum etapesHit { START, ACTIVE, RECUP }
        etapesHit etape;
        
        // compte les frames passées dans le hit
        int current_frame;

        #endregion

        #region INITIALISATION
        public Hit()
        {
            current_frame = 0;
            etape = etapesHit.START;
        }
        #endregion

        #region UPDATE

        // return true quand le hit est terminé
        public bool update()
        {     
            // Ici on détermine dans quel état on se trouve en fonction de la currentframe
            switch (etape)
            {
                case etapesHit.START:
                    if (current_frame >= nbFStart)
                        etape = etapesHit.ACTIVE;
                    break;
                case etapesHit.ACTIVE:
                    if (current_frame >= nbFStart + nbFActives)
                        etape = etapesHit.RECUP;
                    break;
                default:    // je considère que default correspond forcément à etapesHit.RECUP
                    if (current_frame >= nbFStart + nbFActives + nbFRecup)
                    {
                        // fin du hit
                        current_frame = 0;
                        return true;
                    }
                    break;
            }
            
            current_frame++;

            return false;
            
        }

        #endregion

        #region AUTRES METHODES

        public PositionVerticale getPositionVerticale()
        {
            // Gestion des flags : pour savoir dans quel état vertical se trouve le perso pendant le coup
            if ((current_frame >= airborn_start) && (current_frame <= airborn_end))
            {
                return PositionVerticale.AIR;
            }
            if ((current_frame >= crouch_start) && (current_frame <= crouch_end))
            {
                return PositionVerticale.CROUCH;
            }
            if ((current_frame >= stand_start) && (current_frame <= stand_end))
            {
                return PositionVerticale.STAND;
            }

            // par defaut (pour que ça compile...)
            return PositionVerticale.STAND;
        }
        public float getVitesseAnimeHitEnCours()
        {
            float vitesse = 0.0f;

            switch (etape)
            {
                case etapesHit.START:
                    vitesse = (endingFStart + 1 - startingFStart) / (60 * nbFStart);
                    break;
                case etapesHit.ACTIVE:
                    vitesse = (endingFActive + 1 - startingFActive) / (60 * nbFActives);
                    break;
                case etapesHit.RECUP:
                    vitesse = (endingFRecup + 1 - startingFRecup) / (60 * nbFRecup);
                    break;                    
            }

            return vitesse;
        }

        #endregion
    }
}
